import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        int[] arr1 = {2, 6, 4, 1};
        int[] arr2 = {1, 2, 34, 3, 4, 5, 7, 23, 12};
        System.out.println(isContinuousOddNum(arr1));
        System.out.println(isContinuousOddNum(arr2));
    }
    //给你一个整数数组 arr，请你判断数组中是否存在连续三个元素都是奇数的情况：如果存在，请返回 true ；否则，返回 false 。
    //输入：arr = [2,6,4,1] 输出：false 解释：不存在连续三个元素都是奇数的情况。
    //输入：arr = [1,2,34,3,4,5,7,23,12] 输出：true 解释：存在连续三个元素都是奇数的情况，即 [5,7,23] 。
    public static boolean isContinuousOddNum(int[] arr){
        int count = 0;
        for (int x : arr) {
            if(x % 2 == 1){
                count++;
                if(count == 3){
                    return true;
                }
            }else {
                count = 0;
            }
        }
        return false;
    }
    public static void main8(String[] args) {
        int[] array1 = {3, 2, 3};
        int[] array2 = {2, 2, 1, 1, 1, 2, 2};
//        System.out.println(findMostNum(array1));
//        System.out.println(findMostNum(array2));
        System.out.println(findMostNum1(array1));
        System.out.println(findMostNum1(array2));
    }
    public static int findMostNum1(int[] arr){
        Arrays.sort(arr);
        return arr[arr.length / 2];
    }

    //给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。
    //你可以假设数组是非空的，并且给定的数组总是存在多数元素。
    //输入：[3,2,3] 输出：3
    //输入：[2,2,1,1,1,2,2] 输出：2
    public static int findMostNum(int[] array){
        int[] count = new int[array.length];
        for (int i = 0; i < array.length; i++) {
            int tmp = array[i];
            for (int j = 0; j < array.length; j++) {
                if(array[j] == tmp){
                    count[i]++;
                }
            }
        }
        int max = 0;
        for (int i = 0; i < array.length; i++) {
            if(max < count[i]){
                max = count[i];
            }
        }
        int res = -1;
        for (int i = 0; i < array.length; i++) {
            if(count[i] == max){
                res = array[i];
                break;
            }
        }
        return res;
    }
    public static void main7(String[] args) {
        int[] array1= {2, 2, 1};
        int[] array2 = {4, 1, 2, 1, 2};
        System.out.println(findSingleNum(array1));
        System.out.println(findSingleNum(array2));

        int[] array3 = {1, 2, 3, 2, 1, 4};
        int[] res = findSingleNum1(array3);
        System.out.println(Arrays.toString(res));
    }
    //给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
    //﻿示例 1:
    //输入: [2,2,1] 输出: 1
    //示例 2:
    //输入: [4,1,2,1,2] 输出: 4
    public static int findSingleNum(int[] array){
        int ret = array[0];
        for (int i = 1; i < array.length; i++) {
            ret ^= array[i];
        }
        return ret;
    }

    public static int[] findSingleNum1(int[] arr){
        int[] res = new int[2];
        int ret = arr[0];
        int i = 0;
        for (i = 1; i < arr.length; i++) {
            ret ^= arr[i];
        }
        //找到第i位，为1
        for (i = 0; i < 32; i++) {
            if(((ret >> i) & 1) != 0){
                break;
            }
        }
        for (int j = 0; j < arr.length; j++) {
            if(((arr[j] >> i) & 1) != 0){
                res[0] ^= arr[j];
            }else{
                res[1] ^= arr[j];
            }
        }
        return res;
    }
    public static void main6(String[] args) {
        int[] array = {2, 7, 11, 15};
        int[] index = sumOfTarget(array, 9);
        System.out.println(Arrays.toString(index));
    }
    //给定一个整数数组 nums 和一个整数目标值 target
    // 请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
    //你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
    //你可以按任意顺序返回答案。示例 1：
    //输入：nums = [2,7,11,15], target = 9
    //输出：[0,1]
    //解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
    public static int[] sumOfTarget(int[] array, int target){
        int[] index = new int[2];
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = i + 1; j < array.length; j++) {
                if(array[i] + array[j] == target){
                    index[0] = i;
                    index[1] = j;
                    break;
                }
            }
        }
        return index;
    }
    public static void main5(String[] args) {
        int[] array = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
        bubbleSort(array);
        System.out.println(Arrays.toString(array));
    }
    //给定一个整型数组, 实现冒泡排序(升序排序)
    public static void bubbleSort(int[] array){
        for (int i = 0; i < array.length - 1; i++) {
            boolean flag = false;
            for (int j = 0; j < array.length - 1 - i; j++) {
                if(array[j] > array[j + 1]){
                    int tmp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = tmp;
                    flag = true;
                }
            }
            if(flag == false){
                break;
            }
        }
    }
    public static void main4(String[] args) {
        int[] array = {2, 4, 6, 8, 7};
        adjustArray(array);
        System.out.println(Arrays.toString(array));
    }
    //调整数组顺序使得奇数位于偶数之前。调整之后，不关心大小顺序。
    //如数组：[1,2,3,4,5,6]
    //调整后可能是：[1, 5, 3, 4, 2, 6]
    public static void adjustArray(int[] array){
        int left = 0;
        int right = array.length - 1;

        while(left < right){
            if(array[left] % 2 == 0 && array[right] % 2 != 0){
                int tmp = array[left];
                array[left] = array[right];
                array[right] = tmp;
                left++;
                right--;
            }
            if(array[left] % 2 != 0){
                left++;
            }
            if(array[right] % 2 == 0){
                right--;
            }
        }
    }
    public static void main3(String[] args) {
        int[] array = {1,2,3,4,5,6,7,8,9,10};
        System.out.println(avg(array));
    }
    //实现一个方法 avg, 以数组为参数, 求数组中所有元素的平均值(注意方法的返回值类型).
    public static double avg(int[] array){
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            sum += array[i];
        }
        return sum / (array.length * 1.0);
    }
    public static void main2(String[] args) {
        int[] array1 = {1,2,3};
        int[] array2 = new int[array1.length];
        //transform(array1);
        array2 = transform1(array1);
        //System.out.println(Arrays.toString(array1));
        System.out.println(Arrays.toString(array2));
    }
    //实现一个方法 transform, 以数组为参数, 循环将数组中的每个元素 乘以 2 ,
    // 并设置到对应的数组元素上. 例如 原数组为 {1, 2, 3}, 修改之后为 {2, 4, 6}
    public static void transform(int[] array){
        for (int i = 0; i < array.length; i++) {
            array[i] *= 2;//修改原数组，不需要返回引用
        }
    }
    public static int[] transform1(int[] array){
        int[] array2 = new int[array.length];
        for (int i = 0; i < array.length; i++) {
            array2[i] = array[i] * 2;//修改原数组，不需要返回引用
        }
        return array2;
    }
    public static void main1(String[] args) {
        int[] arr = {1,2,3,4,5};
        System.out.println(myToString(arr));
    }
    public static String myToString(int[] arr){
        String s = "[";
        int i = 0;
        for(i = 0; i < arr.length; i++){
            if(i == arr.length - 1){
                s = s + arr[i] + "]";
            }else{
                s = s + arr[i] + ", ";
            }
        }
        return s;
    }
}